package com.hss.backservice.service;

import android.app.ActivityManager;
import android.app.job.JobInfo;
import android.app.job.JobParameters;
import android.app.job.JobScheduler;
import android.app.job.JobService;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.util.Log;
import android.widget.Toast;

import java.util.List;

/**
 * Created by Administrator on 2016/12/21.
 */
//https://www.cnblogs.com/mingfeng002/p/8359573.html

public class JobHandleService extends JobService {
    private int kJobId = 0;


    @Override
    public void onCreate() {
        super.onCreate();
        Log.i("JobHandleService", " create");

    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.i("JobHandleService", "onStartCommand");

        scheduleJob(generate());
        return START_STICKY;
    }

    @Override
    public boolean onStartJob(JobParameters params) {
        Log.e("JobHandleService", "job start");
        Toast.makeText(this, "onStartJob", Toast.LENGTH_SHORT).show();

        boolean isLocalServiceWork = isServiceWork(this, "com.hss.backservice.service.LocalService");
        boolean isRemoteServiceWork = isServiceWork(this, "com.hss.backservice.service.RemoteService");
        if(!isLocalServiceWork||
                !isRemoteServiceWork){
            this.startService(new Intent(this,LocalService.class));
            this.startService(new Intent(this,RemoteService.class));
            Toast.makeText(this, "process start", Toast.LENGTH_SHORT).show();
        }
        jobFinished(params,true);
        return true;
    }

    @Override
    public boolean onStopJob(JobParameters params) {
        Log.e("JobHandleService", " onStopJob");

        scheduleJob(generate());
        Toast.makeText(this, "onStopJob", Toast.LENGTH_SHORT).show();

        return true;
    }


    JobInfo generate(){
//        JobInfo jobInfo=new JobInfo.Builder(kJobId++,new ComponentName(this, JobHandleService.class)).
//                    /*
//                    * 这会使你的工作不启动直到规定的毫秒数已经过去了
//                    * */
//        setPersisted(true).//这个方法告诉系统当你的设备重启之后你的任务是否还要继续执行。
//        setRequiresCharging(false).//这个方法告诉你的应用，只有当设备在充电时这个任务才会被执行。
//        setRequiresDeviceIdle(false).//这个方法告诉你的任务只有当用户没有在使用该设备且有一段时间没有使用时才会启动该任务。
//        setPeriodic(10)//间隔时间--周期
//                    /*
//                    * 只有在设备处于一种特定的网络中时，它才启动
//                    * 默认值是JobInfo.NETWORK_TYPE_NONE :无论是否有网络连接，该任务均可以运行
//                    * JobInfo.NETWORK_TYPE_ANY，这需要某种类型的网络连接可用，工作才可以运行
//                    * JobInfo.NETWORK_TYPE_UNMETERED，这就要求设备在非蜂窝网络中
//                    * */
//                .setRequiredNetworkType(JobInfo.NETWORK_TYPE_ANY)
//                .build();
//        return  jobInfo;


//        JobInfo.Builder builder = new JobInfo.Builder(kJobId++, new ComponentName(this, JobHandleService.class));
//        builder.setRequiredNetworkType(JobInfo.NETWORK_TYPE_ANY);
//        builder.setPersisted(true);
//        builder.setRequiresCharging(false);
//        builder.setRequiresDeviceIdle(false);
//        builder.setPeriodic(10);//间隔时间--周期
//        return builder.build();


        JobInfo jobInfo=new JobInfo.Builder(kJobId++,new ComponentName(this, JobHandleService.class))
                    /*
                    * 这会使你的工作不启动直到规定的毫秒数已经过去了
                    * */
                .setMinimumLatency(5000)
                    /*
                    * 这将设置你的工作期限。即使是无法满足其他要求，你的任务将约在规定的时间已经过去时开始执行
                    * */
                .setOverrideDeadline(60000)
                    /*
                    * 只有在设备处于一种特定的网络中时，它才启动
                    * 默认值是JobInfo.NETWORK_TYPE_NONE :无论是否有网络连接，该任务均可以运行
                    * JobInfo.NETWORK_TYPE_ANY，这需要某种类型的网络连接可用，工作才可以运行
                    * JobInfo.NETWORK_TYPE_UNMETERED，这就要求设备在非蜂窝网络中
                    * */
                .setRequiredNetworkType(JobInfo.NETWORK_TYPE_ANY)
                .build();
        return jobInfo;
    }
    /** Send job to the JobScheduler. */
    public void scheduleJob(JobInfo t) {
        Log.e("INFO", "Scheduling job");
        JobScheduler tm =
                (JobScheduler) getSystemService(Context.JOB_SCHEDULER_SERVICE);
        tm.schedule(t);
//        tm.cancelAll();
    }
    /**
     * 判断某个服务是否正在运行的方法
     *
     * @param mContext
     * @param serviceName
     *            是包名+服务的类名（例如：net.loonggg.testbackstage.TestService）
     * @return true代表正在运行，false代表服务没有正在运行
     */
    public boolean isServiceWork(Context mContext, String serviceName) {
        boolean isWork = false;
        ActivityManager myAM = (ActivityManager) mContext
                .getSystemService(Context.ACTIVITY_SERVICE);
        List<ActivityManager.RunningServiceInfo> myList = myAM.getRunningServices(100);
        if (myList.size() <= 0) {
            return false;
        }
        for (int i = 0; i < myList.size(); i++) {
            String mName = myList.get(i).service.getClassName().toString();
            if (mName.equals(serviceName)) {
                isWork = true;
                break;
            }
        }
        return isWork;
    }
}
